% Copyright (c) 2013-2014, Cornell University
% All rights reserved.
%
% Redistribution and use in source and binary forms, with or without
% modification, are permitted provided that the following conditions are met:
%
%     * Redistributions of source code must retain the above copyright notice,
%       this list of conditions and the following disclaimer.
%     * Redistributions in binary form must reproduce the above copyright
%       notice, this list of conditions and the following disclaimer in the
%       documentation and/or other materials provided with the distribution.
%     * Neither the name of HyperDex nor the names of its contributors may be
%       used to endorse or promote products derived from this software without
%       specific prior written permission.
%
% THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
% AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
% IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
% DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
% FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
% DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
% SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
% CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
% OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
% OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

% This LaTeX file is generated by bindings/ruby.py

%%%%%%%%%%%%%%%%%%%% get %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{get}}
\label{api:ruby:get}
\index{get!Ruby API}
\input{\topdir/client/fragments/get}

\paragraph{Definition:}
\begin{rubycode}
get(spacename, key)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_attributes}

\pagebreak
\subsubsection{\code{async\_get}}
\label{api:ruby:async_get}
\index{async\_get!Ruby API}
\input{\topdir/client/fragments/get}

\paragraph{Definition:}
\begin{rubycode}
async_get(spacename, key)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_attributes}

\paragraph{See also:}  This is the asynchronous form of \code{get}.

%%%%%%%%%%%%%%%%%%%% get_partial %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{get\_partial}}
\label{api:ruby:get_partial}
\index{get\_partial!Ruby API}
\input{\topdir/client/fragments/get_partial}

\paragraph{Definition:}
\begin{rubycode}
get_partial(spacename, key, attributenames)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributenames}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributenames}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_attributes}

\pagebreak
\subsubsection{\code{async\_get\_partial}}
\label{api:ruby:async_get_partial}
\index{async\_get\_partial!Ruby API}
\input{\topdir/client/fragments/get_partial}

\paragraph{Definition:}
\begin{rubycode}
async_get_partial(spacename, key, attributenames)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributenames}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributenames}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_attributes}

\paragraph{See also:}  This is the asynchronous form of \code{get\_partial}.

%%%%%%%%%%%%%%%%%%%% put %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{put}}
\label{api:ruby:put}
\index{put!Ruby API}
\input{\topdir/client/fragments/put}

\paragraph{Definition:}
\begin{rubycode}
put(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_put}}
\label{api:ruby:async_put}
\index{async\_put!Ruby API}
\input{\topdir/client/fragments/put}

\paragraph{Definition:}
\begin{rubycode}
async_put(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{put}.

%%%%%%%%%%%%%%%%%%%% cond_put %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_put}}
\label{api:ruby:cond_put}
\index{cond\_put!Ruby API}
\input{\topdir/client/fragments/cond_put}

\paragraph{Definition:}
\begin{rubycode}
cond_put(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_put}}
\label{api:ruby:async_cond_put}
\index{async\_cond\_put!Ruby API}
\input{\topdir/client/fragments/cond_put}

\paragraph{Definition:}
\begin{rubycode}
async_cond_put(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_put}.

%%%%%%%%%%%%%%%%%%%% cond_put_or_create %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_put\_or\_create}}
\label{api:ruby:cond_put_or_create}
\index{cond\_put\_or\_create!Ruby API}
\input{\topdir/client/fragments/cond_put_or_create}

\paragraph{Definition:}
\begin{rubycode}
cond_put_or_create(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_put\_or\_create}}
\label{api:ruby:async_cond_put_or_create}
\index{async\_cond\_put\_or\_create!Ruby API}
\input{\topdir/client/fragments/cond_put_or_create}

\paragraph{Definition:}
\begin{rubycode}
async_cond_put_or_create(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_put\_or\_create}.

%%%%%%%%%%%%%%%%%%%% group_put %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_put}}
\label{api:ruby:group_put}
\index{group\_put!Ruby API}
\input{\topdir/client/fragments/group_put}

\paragraph{Definition:}
\begin{rubycode}
group_put(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_put}}
\label{api:ruby:async_group_put}
\index{async\_group\_put!Ruby API}
\input{\topdir/client/fragments/group_put}

\paragraph{Definition:}
\begin{rubycode}
async_group_put(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_put}.

%%%%%%%%%%%%%%%%%%%% put_if_not_exist %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{put\_if\_not\_exist}}
\label{api:ruby:put_if_not_exist}
\index{put\_if\_not\_exist!Ruby API}
\input{\topdir/client/fragments/put_if_not_exist}

\paragraph{Definition:}
\begin{rubycode}
put_if_not_exist(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_put\_if\_not\_exist}}
\label{api:ruby:async_put_if_not_exist}
\index{async\_put\_if\_not\_exist!Ruby API}
\input{\topdir/client/fragments/put_if_not_exist}

\paragraph{Definition:}
\begin{rubycode}
async_put_if_not_exist(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{put\_if\_not\_exist}.

%%%%%%%%%%%%%%%%%%%% del %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{del}}
\label{api:ruby:del}
\index{del!Ruby API}
\input{\topdir/client/fragments/del}

\paragraph{Definition:}
\begin{rubycode}
del(spacename, key)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_del}}
\label{api:ruby:async_del}
\index{async\_del!Ruby API}
\input{\topdir/client/fragments/del}

\paragraph{Definition:}
\begin{rubycode}
async_del(spacename, key)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{del}.

%%%%%%%%%%%%%%%%%%%% cond_del %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_del}}
\label{api:ruby:cond_del}
\index{cond\_del!Ruby API}
\input{\topdir/client/fragments/cond_del}

\paragraph{Definition:}
\begin{rubycode}
cond_del(spacename, key, predicates)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_del}}
\label{api:ruby:async_cond_del}
\index{async\_cond\_del!Ruby API}
\input{\topdir/client/fragments/cond_del}

\paragraph{Definition:}
\begin{rubycode}
async_cond_del(spacename, key, predicates)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_del}.

%%%%%%%%%%%%%%%%%%%% group_del %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_del}}
\label{api:ruby:group_del}
\index{group\_del!Ruby API}
\input{\topdir/client/fragments/group_del}

\paragraph{Definition:}
\begin{rubycode}
group_del(spacename, predicates)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_del}}
\label{api:ruby:async_group_del}
\index{async\_group\_del!Ruby API}
\input{\topdir/client/fragments/group_del}

\paragraph{Definition:}
\begin{rubycode}
async_group_del(spacename, predicates)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_del}.

%%%%%%%%%%%%%%%%%%%% atomic_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{atomic\_add}}
\label{api:ruby:atomic_add}
\index{atomic\_add!Ruby API}
\input{\topdir/client/fragments/atomic_add}

\paragraph{Definition:}
\begin{rubycode}
atomic_add(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_atomic\_add}}
\label{api:ruby:async_atomic_add}
\index{async\_atomic\_add!Ruby API}
\input{\topdir/client/fragments/atomic_add}

\paragraph{Definition:}
\begin{rubycode}
async_atomic_add(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{atomic\_add}.

%%%%%%%%%%%%%%%%%%%% cond_atomic_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_atomic\_add}}
\label{api:ruby:cond_atomic_add}
\index{cond\_atomic\_add!Ruby API}
\input{\topdir/client/fragments/cond_atomic_add}

\paragraph{Definition:}
\begin{rubycode}
cond_atomic_add(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_atomic\_add}}
\label{api:ruby:async_cond_atomic_add}
\index{async\_cond\_atomic\_add!Ruby API}
\input{\topdir/client/fragments/cond_atomic_add}

\paragraph{Definition:}
\begin{rubycode}
async_cond_atomic_add(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_atomic\_add}.

%%%%%%%%%%%%%%%%%%%% group_atomic_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_atomic\_add}}
\label{api:ruby:group_atomic_add}
\index{group\_atomic\_add!Ruby API}
\input{\topdir/client/fragments/group_atomic_add}

\paragraph{Definition:}
\begin{rubycode}
group_atomic_add(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_atomic\_add}}
\label{api:ruby:async_group_atomic_add}
\index{async\_group\_atomic\_add!Ruby API}
\input{\topdir/client/fragments/group_atomic_add}

\paragraph{Definition:}
\begin{rubycode}
async_group_atomic_add(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_atomic\_add}.

%%%%%%%%%%%%%%%%%%%% atomic_sub %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{atomic\_sub}}
\label{api:ruby:atomic_sub}
\index{atomic\_sub!Ruby API}
\input{\topdir/client/fragments/atomic_sub}

\paragraph{Definition:}
\begin{rubycode}
atomic_sub(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_atomic\_sub}}
\label{api:ruby:async_atomic_sub}
\index{async\_atomic\_sub!Ruby API}
\input{\topdir/client/fragments/atomic_sub}

\paragraph{Definition:}
\begin{rubycode}
async_atomic_sub(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{atomic\_sub}.

%%%%%%%%%%%%%%%%%%%% cond_atomic_sub %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_atomic\_sub}}
\label{api:ruby:cond_atomic_sub}
\index{cond\_atomic\_sub!Ruby API}
\input{\topdir/client/fragments/cond_atomic_sub}

\paragraph{Definition:}
\begin{rubycode}
cond_atomic_sub(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_atomic\_sub}}
\label{api:ruby:async_cond_atomic_sub}
\index{async\_cond\_atomic\_sub!Ruby API}
\input{\topdir/client/fragments/cond_atomic_sub}

\paragraph{Definition:}
\begin{rubycode}
async_cond_atomic_sub(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_atomic\_sub}.

%%%%%%%%%%%%%%%%%%%% group_atomic_sub %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_atomic\_sub}}
\label{api:ruby:group_atomic_sub}
\index{group\_atomic\_sub!Ruby API}
\input{\topdir/client/fragments/group_atomic_sub}

\paragraph{Definition:}
\begin{rubycode}
group_atomic_sub(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_atomic\_sub}}
\label{api:ruby:async_group_atomic_sub}
\index{async\_group\_atomic\_sub!Ruby API}
\input{\topdir/client/fragments/group_atomic_sub}

\paragraph{Definition:}
\begin{rubycode}
async_group_atomic_sub(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_atomic\_sub}.

%%%%%%%%%%%%%%%%%%%% atomic_mul %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{atomic\_mul}}
\label{api:ruby:atomic_mul}
\index{atomic\_mul!Ruby API}
\input{\topdir/client/fragments/atomic_mul}

\paragraph{Definition:}
\begin{rubycode}
atomic_mul(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_atomic\_mul}}
\label{api:ruby:async_atomic_mul}
\index{async\_atomic\_mul!Ruby API}
\input{\topdir/client/fragments/atomic_mul}

\paragraph{Definition:}
\begin{rubycode}
async_atomic_mul(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{atomic\_mul}.

%%%%%%%%%%%%%%%%%%%% cond_atomic_mul %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_atomic\_mul}}
\label{api:ruby:cond_atomic_mul}
\index{cond\_atomic\_mul!Ruby API}
\input{\topdir/client/fragments/cond_atomic_mul}

\paragraph{Definition:}
\begin{rubycode}
cond_atomic_mul(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_atomic\_mul}}
\label{api:ruby:async_cond_atomic_mul}
\index{async\_cond\_atomic\_mul!Ruby API}
\input{\topdir/client/fragments/cond_atomic_mul}

\paragraph{Definition:}
\begin{rubycode}
async_cond_atomic_mul(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_atomic\_mul}.

%%%%%%%%%%%%%%%%%%%% group_atomic_mul %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_atomic\_mul}}
\label{api:ruby:group_atomic_mul}
\index{group\_atomic\_mul!Ruby API}
\input{\topdir/client/fragments/group_atomic_mul}

\paragraph{Definition:}
\begin{rubycode}
group_atomic_mul(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_atomic\_mul}}
\label{api:ruby:async_group_atomic_mul}
\index{async\_group\_atomic\_mul!Ruby API}
\input{\topdir/client/fragments/group_atomic_mul}

\paragraph{Definition:}
\begin{rubycode}
async_group_atomic_mul(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_atomic\_mul}.

%%%%%%%%%%%%%%%%%%%% atomic_div %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{atomic\_div}}
\label{api:ruby:atomic_div}
\index{atomic\_div!Ruby API}
\input{\topdir/client/fragments/atomic_div}

\paragraph{Definition:}
\begin{rubycode}
atomic_div(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_atomic\_div}}
\label{api:ruby:async_atomic_div}
\index{async\_atomic\_div!Ruby API}
\input{\topdir/client/fragments/atomic_div}

\paragraph{Definition:}
\begin{rubycode}
async_atomic_div(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{atomic\_div}.

%%%%%%%%%%%%%%%%%%%% cond_atomic_div %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_atomic\_div}}
\label{api:ruby:cond_atomic_div}
\index{cond\_atomic\_div!Ruby API}
\input{\topdir/client/fragments/cond_atomic_div}

\paragraph{Definition:}
\begin{rubycode}
cond_atomic_div(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_atomic\_div}}
\label{api:ruby:async_cond_atomic_div}
\index{async\_cond\_atomic\_div!Ruby API}
\input{\topdir/client/fragments/cond_atomic_div}

\paragraph{Definition:}
\begin{rubycode}
async_cond_atomic_div(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_atomic\_div}.

%%%%%%%%%%%%%%%%%%%% group_atomic_div %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_atomic\_div}}
\label{api:ruby:group_atomic_div}
\index{group\_atomic\_div!Ruby API}
\input{\topdir/client/fragments/group_atomic_div}

\paragraph{Definition:}
\begin{rubycode}
group_atomic_div(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_atomic\_div}}
\label{api:ruby:async_group_atomic_div}
\index{async\_group\_atomic\_div!Ruby API}
\input{\topdir/client/fragments/group_atomic_div}

\paragraph{Definition:}
\begin{rubycode}
async_group_atomic_div(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_atomic\_div}.

%%%%%%%%%%%%%%%%%%%% atomic_mod %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{atomic\_mod}}
\label{api:ruby:atomic_mod}
\index{atomic\_mod!Ruby API}
\input{\topdir/client/fragments/atomic_mod}

\paragraph{Definition:}
\begin{rubycode}
atomic_mod(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_atomic\_mod}}
\label{api:ruby:async_atomic_mod}
\index{async\_atomic\_mod!Ruby API}
\input{\topdir/client/fragments/atomic_mod}

\paragraph{Definition:}
\begin{rubycode}
async_atomic_mod(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{atomic\_mod}.

%%%%%%%%%%%%%%%%%%%% cond_atomic_mod %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_atomic\_mod}}
\label{api:ruby:cond_atomic_mod}
\index{cond\_atomic\_mod!Ruby API}
\input{\topdir/client/fragments/cond_atomic_mod}

\paragraph{Definition:}
\begin{rubycode}
cond_atomic_mod(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_atomic\_mod}}
\label{api:ruby:async_cond_atomic_mod}
\index{async\_cond\_atomic\_mod!Ruby API}
\input{\topdir/client/fragments/cond_atomic_mod}

\paragraph{Definition:}
\begin{rubycode}
async_cond_atomic_mod(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_atomic\_mod}.

%%%%%%%%%%%%%%%%%%%% group_atomic_mod %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_atomic\_mod}}
\label{api:ruby:group_atomic_mod}
\index{group\_atomic\_mod!Ruby API}
\input{\topdir/client/fragments/group_atomic_mod}

\paragraph{Definition:}
\begin{rubycode}
group_atomic_mod(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_atomic\_mod}}
\label{api:ruby:async_group_atomic_mod}
\index{async\_group\_atomic\_mod!Ruby API}
\input{\topdir/client/fragments/group_atomic_mod}

\paragraph{Definition:}
\begin{rubycode}
async_group_atomic_mod(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_atomic\_mod}.

%%%%%%%%%%%%%%%%%%%% atomic_and %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{atomic\_and}}
\label{api:ruby:atomic_and}
\index{atomic\_and!Ruby API}
\input{\topdir/client/fragments/atomic_and}

\paragraph{Definition:}
\begin{rubycode}
atomic_and(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_atomic\_and}}
\label{api:ruby:async_atomic_and}
\index{async\_atomic\_and!Ruby API}
\input{\topdir/client/fragments/atomic_and}

\paragraph{Definition:}
\begin{rubycode}
async_atomic_and(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{atomic\_and}.

%%%%%%%%%%%%%%%%%%%% cond_atomic_and %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_atomic\_and}}
\label{api:ruby:cond_atomic_and}
\index{cond\_atomic\_and!Ruby API}
\input{\topdir/client/fragments/cond_atomic_and}

\paragraph{Definition:}
\begin{rubycode}
cond_atomic_and(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_atomic\_and}}
\label{api:ruby:async_cond_atomic_and}
\index{async\_cond\_atomic\_and!Ruby API}
\input{\topdir/client/fragments/cond_atomic_and}

\paragraph{Definition:}
\begin{rubycode}
async_cond_atomic_and(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_atomic\_and}.

%%%%%%%%%%%%%%%%%%%% group_atomic_and %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_atomic\_and}}
\label{api:ruby:group_atomic_and}
\index{group\_atomic\_and!Ruby API}
\input{\topdir/client/fragments/group_atomic_and}

\paragraph{Definition:}
\begin{rubycode}
group_atomic_and(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_atomic\_and}}
\label{api:ruby:async_group_atomic_and}
\index{async\_group\_atomic\_and!Ruby API}
\input{\topdir/client/fragments/group_atomic_and}

\paragraph{Definition:}
\begin{rubycode}
async_group_atomic_and(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_atomic\_and}.

%%%%%%%%%%%%%%%%%%%% atomic_or %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{atomic\_or}}
\label{api:ruby:atomic_or}
\index{atomic\_or!Ruby API}
\input{\topdir/client/fragments/atomic_or}

\paragraph{Definition:}
\begin{rubycode}
atomic_or(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_atomic\_or}}
\label{api:ruby:async_atomic_or}
\index{async\_atomic\_or!Ruby API}
\input{\topdir/client/fragments/atomic_or}

\paragraph{Definition:}
\begin{rubycode}
async_atomic_or(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{atomic\_or}.

%%%%%%%%%%%%%%%%%%%% cond_atomic_or %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_atomic\_or}}
\label{api:ruby:cond_atomic_or}
\index{cond\_atomic\_or!Ruby API}
\input{\topdir/client/fragments/cond_atomic_or}

\paragraph{Definition:}
\begin{rubycode}
cond_atomic_or(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_atomic\_or}}
\label{api:ruby:async_cond_atomic_or}
\index{async\_cond\_atomic\_or!Ruby API}
\input{\topdir/client/fragments/cond_atomic_or}

\paragraph{Definition:}
\begin{rubycode}
async_cond_atomic_or(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_atomic\_or}.

%%%%%%%%%%%%%%%%%%%% group_atomic_or %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_atomic\_or}}
\label{api:ruby:group_atomic_or}
\index{group\_atomic\_or!Ruby API}
\input{\topdir/client/fragments/group_atomic_or}

\paragraph{Definition:}
\begin{rubycode}
group_atomic_or(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_atomic\_or}}
\label{api:ruby:async_group_atomic_or}
\index{async\_group\_atomic\_or!Ruby API}
\input{\topdir/client/fragments/group_atomic_or}

\paragraph{Definition:}
\begin{rubycode}
async_group_atomic_or(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_atomic\_or}.

%%%%%%%%%%%%%%%%%%%% atomic_xor %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{atomic\_xor}}
\label{api:ruby:atomic_xor}
\index{atomic\_xor!Ruby API}
\input{\topdir/client/fragments/atomic_xor}

\paragraph{Definition:}
\begin{rubycode}
atomic_xor(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_atomic\_xor}}
\label{api:ruby:async_atomic_xor}
\index{async\_atomic\_xor!Ruby API}
\input{\topdir/client/fragments/atomic_xor}

\paragraph{Definition:}
\begin{rubycode}
async_atomic_xor(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{atomic\_xor}.

%%%%%%%%%%%%%%%%%%%% cond_atomic_xor %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_atomic\_xor}}
\label{api:ruby:cond_atomic_xor}
\index{cond\_atomic\_xor!Ruby API}
\input{\topdir/client/fragments/cond_atomic_xor}

\paragraph{Definition:}
\begin{rubycode}
cond_atomic_xor(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_atomic\_xor}}
\label{api:ruby:async_cond_atomic_xor}
\index{async\_cond\_atomic\_xor!Ruby API}
\input{\topdir/client/fragments/cond_atomic_xor}

\paragraph{Definition:}
\begin{rubycode}
async_cond_atomic_xor(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_atomic\_xor}.

%%%%%%%%%%%%%%%%%%%% group_atomic_xor %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_atomic\_xor}}
\label{api:ruby:group_atomic_xor}
\index{group\_atomic\_xor!Ruby API}
\input{\topdir/client/fragments/group_atomic_xor}

\paragraph{Definition:}
\begin{rubycode}
group_atomic_xor(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_atomic\_xor}}
\label{api:ruby:async_group_atomic_xor}
\index{async\_group\_atomic\_xor!Ruby API}
\input{\topdir/client/fragments/group_atomic_xor}

\paragraph{Definition:}
\begin{rubycode}
async_group_atomic_xor(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_atomic\_xor}.

%%%%%%%%%%%%%%%%%%%% atomic_min %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{atomic\_min}}
\label{api:ruby:atomic_min}
\index{atomic\_min!Ruby API}
\input{\topdir/client/fragments/atomic_min}

\paragraph{Definition:}
\begin{rubycode}
atomic_min(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_atomic\_min}}
\label{api:ruby:async_atomic_min}
\index{async\_atomic\_min!Ruby API}
\input{\topdir/client/fragments/atomic_min}

\paragraph{Definition:}
\begin{rubycode}
async_atomic_min(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{atomic\_min}.

%%%%%%%%%%%%%%%%%%%% cond_atomic_min %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_atomic\_min}}
\label{api:ruby:cond_atomic_min}
\index{cond\_atomic\_min!Ruby API}
\input{\topdir/client/fragments/cond_atomic_min}

\paragraph{Definition:}
\begin{rubycode}
cond_atomic_min(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_atomic\_min}}
\label{api:ruby:async_cond_atomic_min}
\index{async\_cond\_atomic\_min!Ruby API}
\input{\topdir/client/fragments/cond_atomic_min}

\paragraph{Definition:}
\begin{rubycode}
async_cond_atomic_min(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_atomic\_min}.

%%%%%%%%%%%%%%%%%%%% group_atomic_min %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_atomic\_min}}
\label{api:ruby:group_atomic_min}
\index{group\_atomic\_min!Ruby API}
\input{\topdir/client/fragments/group_atomic_min}

\paragraph{Definition:}
\begin{rubycode}
group_atomic_min(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_atomic\_min}}
\label{api:ruby:async_group_atomic_min}
\index{async\_group\_atomic\_min!Ruby API}
\input{\topdir/client/fragments/group_atomic_min}

\paragraph{Definition:}
\begin{rubycode}
async_group_atomic_min(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_atomic\_min}.

%%%%%%%%%%%%%%%%%%%% atomic_max %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{atomic\_max}}
\label{api:ruby:atomic_max}
\index{atomic\_max!Ruby API}
\input{\topdir/client/fragments/atomic_max}

\paragraph{Definition:}
\begin{rubycode}
atomic_max(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_atomic\_max}}
\label{api:ruby:async_atomic_max}
\index{async\_atomic\_max!Ruby API}
\input{\topdir/client/fragments/atomic_max}

\paragraph{Definition:}
\begin{rubycode}
async_atomic_max(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{atomic\_max}.

%%%%%%%%%%%%%%%%%%%% cond_atomic_max %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_atomic\_max}}
\label{api:ruby:cond_atomic_max}
\index{cond\_atomic\_max!Ruby API}
\input{\topdir/client/fragments/cond_atomic_max}

\paragraph{Definition:}
\begin{rubycode}
cond_atomic_max(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_atomic\_max}}
\label{api:ruby:async_cond_atomic_max}
\index{async\_cond\_atomic\_max!Ruby API}
\input{\topdir/client/fragments/cond_atomic_max}

\paragraph{Definition:}
\begin{rubycode}
async_cond_atomic_max(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_atomic\_max}.

%%%%%%%%%%%%%%%%%%%% group_atomic_max %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_atomic\_max}}
\label{api:ruby:group_atomic_max}
\index{group\_atomic\_max!Ruby API}
\input{\topdir/client/fragments/group_atomic_max}

\paragraph{Definition:}
\begin{rubycode}
group_atomic_max(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_atomic\_max}}
\label{api:ruby:async_group_atomic_max}
\index{async\_group\_atomic\_max!Ruby API}
\input{\topdir/client/fragments/group_atomic_max}

\paragraph{Definition:}
\begin{rubycode}
async_group_atomic_max(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_atomic\_max}.

%%%%%%%%%%%%%%%%%%%% string_prepend %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{string\_prepend}}
\label{api:ruby:string_prepend}
\index{string\_prepend!Ruby API}
\input{\topdir/client/fragments/string_prepend}

\paragraph{Definition:}
\begin{rubycode}
string_prepend(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_string\_prepend}}
\label{api:ruby:async_string_prepend}
\index{async\_string\_prepend!Ruby API}
\input{\topdir/client/fragments/string_prepend}

\paragraph{Definition:}
\begin{rubycode}
async_string_prepend(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{string\_prepend}.

%%%%%%%%%%%%%%%%%%%% cond_string_prepend %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_string\_prepend}}
\label{api:ruby:cond_string_prepend}
\index{cond\_string\_prepend!Ruby API}
\input{\topdir/client/fragments/cond_string_prepend}

\paragraph{Definition:}
\begin{rubycode}
cond_string_prepend(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_string\_prepend}}
\label{api:ruby:async_cond_string_prepend}
\index{async\_cond\_string\_prepend!Ruby API}
\input{\topdir/client/fragments/cond_string_prepend}

\paragraph{Definition:}
\begin{rubycode}
async_cond_string_prepend(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_string\_prepend}.

%%%%%%%%%%%%%%%%%%%% group_string_prepend %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_string\_prepend}}
\label{api:ruby:group_string_prepend}
\index{group\_string\_prepend!Ruby API}
\input{\topdir/client/fragments/group_string_prepend}

\paragraph{Definition:}
\begin{rubycode}
group_string_prepend(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_string\_prepend}}
\label{api:ruby:async_group_string_prepend}
\index{async\_group\_string\_prepend!Ruby API}
\input{\topdir/client/fragments/group_string_prepend}

\paragraph{Definition:}
\begin{rubycode}
async_group_string_prepend(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_string\_prepend}.

%%%%%%%%%%%%%%%%%%%% string_append %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{string\_append}}
\label{api:ruby:string_append}
\index{string\_append!Ruby API}
\input{\topdir/client/fragments/string_append}

\paragraph{Definition:}
\begin{rubycode}
string_append(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_string\_append}}
\label{api:ruby:async_string_append}
\index{async\_string\_append!Ruby API}
\input{\topdir/client/fragments/string_append}

\paragraph{Definition:}
\begin{rubycode}
async_string_append(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{string\_append}.

%%%%%%%%%%%%%%%%%%%% cond_string_append %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_string\_append}}
\label{api:ruby:cond_string_append}
\index{cond\_string\_append!Ruby API}
\input{\topdir/client/fragments/cond_string_append}

\paragraph{Definition:}
\begin{rubycode}
cond_string_append(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_string\_append}}
\label{api:ruby:async_cond_string_append}
\index{async\_cond\_string\_append!Ruby API}
\input{\topdir/client/fragments/cond_string_append}

\paragraph{Definition:}
\begin{rubycode}
async_cond_string_append(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_string\_append}.

%%%%%%%%%%%%%%%%%%%% group_string_append %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_string\_append}}
\label{api:ruby:group_string_append}
\index{group\_string\_append!Ruby API}
\input{\topdir/client/fragments/group_string_append}

\paragraph{Definition:}
\begin{rubycode}
group_string_append(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_string\_append}}
\label{api:ruby:async_group_string_append}
\index{async\_group\_string\_append!Ruby API}
\input{\topdir/client/fragments/group_string_append}

\paragraph{Definition:}
\begin{rubycode}
async_group_string_append(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_string\_append}.

%%%%%%%%%%%%%%%%%%%% string_ltrim %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{string\_ltrim}}
\label{api:ruby:string_ltrim}
\index{string\_ltrim!Ruby API}
\input{\topdir/client/fragments/string_ltrim}

\paragraph{Definition:}
\begin{rubycode}
string_ltrim(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_string\_ltrim}}
\label{api:ruby:async_string_ltrim}
\index{async\_string\_ltrim!Ruby API}
\input{\topdir/client/fragments/string_ltrim}

\paragraph{Definition:}
\begin{rubycode}
async_string_ltrim(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{string\_ltrim}.

%%%%%%%%%%%%%%%%%%%% cond_string_ltrim %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_string\_ltrim}}
\label{api:ruby:cond_string_ltrim}
\index{cond\_string\_ltrim!Ruby API}
\input{\topdir/client/fragments/cond_string_ltrim}

\paragraph{Definition:}
\begin{rubycode}
cond_string_ltrim(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_string\_ltrim}}
\label{api:ruby:async_cond_string_ltrim}
\index{async\_cond\_string\_ltrim!Ruby API}
\input{\topdir/client/fragments/cond_string_ltrim}

\paragraph{Definition:}
\begin{rubycode}
async_cond_string_ltrim(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_string\_ltrim}.

%%%%%%%%%%%%%%%%%%%% group_string_ltrim %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_string\_ltrim}}
\label{api:ruby:group_string_ltrim}
\index{group\_string\_ltrim!Ruby API}
\input{\topdir/client/fragments/group_string_ltrim}

\paragraph{Definition:}
\begin{rubycode}
group_string_ltrim(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_string\_ltrim}}
\label{api:ruby:async_group_string_ltrim}
\index{async\_group\_string\_ltrim!Ruby API}
\input{\topdir/client/fragments/group_string_ltrim}

\paragraph{Definition:}
\begin{rubycode}
async_group_string_ltrim(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_string\_ltrim}.

%%%%%%%%%%%%%%%%%%%% string_rtrim %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{string\_rtrim}}
\label{api:ruby:string_rtrim}
\index{string\_rtrim!Ruby API}
\input{\topdir/client/fragments/string_rtrim}

\paragraph{Definition:}
\begin{rubycode}
string_rtrim(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_string\_rtrim}}
\label{api:ruby:async_string_rtrim}
\index{async\_string\_rtrim!Ruby API}
\input{\topdir/client/fragments/string_rtrim}

\paragraph{Definition:}
\begin{rubycode}
async_string_rtrim(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{string\_rtrim}.

%%%%%%%%%%%%%%%%%%%% cond_string_rtrim %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_string\_rtrim}}
\label{api:ruby:cond_string_rtrim}
\index{cond\_string\_rtrim!Ruby API}
\input{\topdir/client/fragments/cond_string_rtrim}

\paragraph{Definition:}
\begin{rubycode}
cond_string_rtrim(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_string\_rtrim}}
\label{api:ruby:async_cond_string_rtrim}
\index{async\_cond\_string\_rtrim!Ruby API}
\input{\topdir/client/fragments/cond_string_rtrim}

\paragraph{Definition:}
\begin{rubycode}
async_cond_string_rtrim(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_string\_rtrim}.

%%%%%%%%%%%%%%%%%%%% group_string_rtrim %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_string\_rtrim}}
\label{api:ruby:group_string_rtrim}
\index{group\_string\_rtrim!Ruby API}
\input{\topdir/client/fragments/group_string_rtrim}

\paragraph{Definition:}
\begin{rubycode}
group_string_rtrim(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_string\_rtrim}}
\label{api:ruby:async_group_string_rtrim}
\index{async\_group\_string\_rtrim!Ruby API}
\input{\topdir/client/fragments/group_string_rtrim}

\paragraph{Definition:}
\begin{rubycode}
async_group_string_rtrim(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_string\_rtrim}.

%%%%%%%%%%%%%%%%%%%% list_lpush %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{list\_lpush}}
\label{api:ruby:list_lpush}
\index{list\_lpush!Ruby API}
\input{\topdir/client/fragments/list_lpush}

\paragraph{Definition:}
\begin{rubycode}
list_lpush(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_list\_lpush}}
\label{api:ruby:async_list_lpush}
\index{async\_list\_lpush!Ruby API}
\input{\topdir/client/fragments/list_lpush}

\paragraph{Definition:}
\begin{rubycode}
async_list_lpush(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{list\_lpush}.

%%%%%%%%%%%%%%%%%%%% cond_list_lpush %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_list\_lpush}}
\label{api:ruby:cond_list_lpush}
\index{cond\_list\_lpush!Ruby API}
\input{\topdir/client/fragments/cond_list_lpush}

\paragraph{Definition:}
\begin{rubycode}
cond_list_lpush(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_list\_lpush}}
\label{api:ruby:async_cond_list_lpush}
\index{async\_cond\_list\_lpush!Ruby API}
\input{\topdir/client/fragments/cond_list_lpush}

\paragraph{Definition:}
\begin{rubycode}
async_cond_list_lpush(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_list\_lpush}.

%%%%%%%%%%%%%%%%%%%% group_list_lpush %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_list\_lpush}}
\label{api:ruby:group_list_lpush}
\index{group\_list\_lpush!Ruby API}
\input{\topdir/client/fragments/group_list_lpush}

\paragraph{Definition:}
\begin{rubycode}
group_list_lpush(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_list\_lpush}}
\label{api:ruby:async_group_list_lpush}
\index{async\_group\_list\_lpush!Ruby API}
\input{\topdir/client/fragments/group_list_lpush}

\paragraph{Definition:}
\begin{rubycode}
async_group_list_lpush(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_list\_lpush}.

%%%%%%%%%%%%%%%%%%%% list_rpush %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{list\_rpush}}
\label{api:ruby:list_rpush}
\index{list\_rpush!Ruby API}
\input{\topdir/client/fragments/list_rpush}

\paragraph{Definition:}
\begin{rubycode}
list_rpush(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_list\_rpush}}
\label{api:ruby:async_list_rpush}
\index{async\_list\_rpush!Ruby API}
\input{\topdir/client/fragments/list_rpush}

\paragraph{Definition:}
\begin{rubycode}
async_list_rpush(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{list\_rpush}.

%%%%%%%%%%%%%%%%%%%% cond_list_rpush %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_list\_rpush}}
\label{api:ruby:cond_list_rpush}
\index{cond\_list\_rpush!Ruby API}
\input{\topdir/client/fragments/cond_list_rpush}

\paragraph{Definition:}
\begin{rubycode}
cond_list_rpush(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_list\_rpush}}
\label{api:ruby:async_cond_list_rpush}
\index{async\_cond\_list\_rpush!Ruby API}
\input{\topdir/client/fragments/cond_list_rpush}

\paragraph{Definition:}
\begin{rubycode}
async_cond_list_rpush(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_list\_rpush}.

%%%%%%%%%%%%%%%%%%%% group_list_rpush %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_list\_rpush}}
\label{api:ruby:group_list_rpush}
\index{group\_list\_rpush!Ruby API}
\input{\topdir/client/fragments/group_list_rpush}

\paragraph{Definition:}
\begin{rubycode}
group_list_rpush(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_list\_rpush}}
\label{api:ruby:async_group_list_rpush}
\index{async\_group\_list\_rpush!Ruby API}
\input{\topdir/client/fragments/group_list_rpush}

\paragraph{Definition:}
\begin{rubycode}
async_group_list_rpush(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_list\_rpush}.

%%%%%%%%%%%%%%%%%%%% set_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{set\_add}}
\label{api:ruby:set_add}
\index{set\_add!Ruby API}
\input{\topdir/client/fragments/set_add}

\paragraph{Definition:}
\begin{rubycode}
set_add(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_set\_add}}
\label{api:ruby:async_set_add}
\index{async\_set\_add!Ruby API}
\input{\topdir/client/fragments/set_add}

\paragraph{Definition:}
\begin{rubycode}
async_set_add(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{set\_add}.

%%%%%%%%%%%%%%%%%%%% cond_set_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_set\_add}}
\label{api:ruby:cond_set_add}
\index{cond\_set\_add!Ruby API}
\input{\topdir/client/fragments/cond_set_add}

\paragraph{Definition:}
\begin{rubycode}
cond_set_add(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_set\_add}}
\label{api:ruby:async_cond_set_add}
\index{async\_cond\_set\_add!Ruby API}
\input{\topdir/client/fragments/cond_set_add}

\paragraph{Definition:}
\begin{rubycode}
async_cond_set_add(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_set\_add}.

%%%%%%%%%%%%%%%%%%%% group_set_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_set\_add}}
\label{api:ruby:group_set_add}
\index{group\_set\_add!Ruby API}
\input{\topdir/client/fragments/group_set_add}

\paragraph{Definition:}
\begin{rubycode}
group_set_add(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_set\_add}}
\label{api:ruby:async_group_set_add}
\index{async\_group\_set\_add!Ruby API}
\input{\topdir/client/fragments/group_set_add}

\paragraph{Definition:}
\begin{rubycode}
async_group_set_add(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_set\_add}.

%%%%%%%%%%%%%%%%%%%% set_remove %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{set\_remove}}
\label{api:ruby:set_remove}
\index{set\_remove!Ruby API}
\input{\topdir/client/fragments/set_remove}

\paragraph{Definition:}
\begin{rubycode}
set_remove(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_set\_remove}}
\label{api:ruby:async_set_remove}
\index{async\_set\_remove!Ruby API}
\input{\topdir/client/fragments/set_remove}

\paragraph{Definition:}
\begin{rubycode}
async_set_remove(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{set\_remove}.

%%%%%%%%%%%%%%%%%%%% cond_set_remove %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_set\_remove}}
\label{api:ruby:cond_set_remove}
\index{cond\_set\_remove!Ruby API}
\input{\topdir/client/fragments/cond_set_remove}

\paragraph{Definition:}
\begin{rubycode}
cond_set_remove(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_set\_remove}}
\label{api:ruby:async_cond_set_remove}
\index{async\_cond\_set\_remove!Ruby API}
\input{\topdir/client/fragments/cond_set_remove}

\paragraph{Definition:}
\begin{rubycode}
async_cond_set_remove(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_set\_remove}.

%%%%%%%%%%%%%%%%%%%% group_set_remove %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_set\_remove}}
\label{api:ruby:group_set_remove}
\index{group\_set\_remove!Ruby API}
\input{\topdir/client/fragments/group_set_remove}

\paragraph{Definition:}
\begin{rubycode}
group_set_remove(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_set\_remove}}
\label{api:ruby:async_group_set_remove}
\index{async\_group\_set\_remove!Ruby API}
\input{\topdir/client/fragments/group_set_remove}

\paragraph{Definition:}
\begin{rubycode}
async_group_set_remove(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_set\_remove}.

%%%%%%%%%%%%%%%%%%%% set_intersect %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{set\_intersect}}
\label{api:ruby:set_intersect}
\index{set\_intersect!Ruby API}
\input{\topdir/client/fragments/set_intersect}

\paragraph{Definition:}
\begin{rubycode}
set_intersect(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_set\_intersect}}
\label{api:ruby:async_set_intersect}
\index{async\_set\_intersect!Ruby API}
\input{\topdir/client/fragments/set_intersect}

\paragraph{Definition:}
\begin{rubycode}
async_set_intersect(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{set\_intersect}.

%%%%%%%%%%%%%%%%%%%% cond_set_intersect %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_set\_intersect}}
\label{api:ruby:cond_set_intersect}
\index{cond\_set\_intersect!Ruby API}
\input{\topdir/client/fragments/cond_set_intersect}

\paragraph{Definition:}
\begin{rubycode}
cond_set_intersect(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_set\_intersect}}
\label{api:ruby:async_cond_set_intersect}
\index{async\_cond\_set\_intersect!Ruby API}
\input{\topdir/client/fragments/cond_set_intersect}

\paragraph{Definition:}
\begin{rubycode}
async_cond_set_intersect(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_set\_intersect}.

%%%%%%%%%%%%%%%%%%%% group_set_intersect %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_set\_intersect}}
\label{api:ruby:group_set_intersect}
\index{group\_set\_intersect!Ruby API}
\input{\topdir/client/fragments/group_set_intersect}

\paragraph{Definition:}
\begin{rubycode}
group_set_intersect(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_set\_intersect}}
\label{api:ruby:async_group_set_intersect}
\index{async\_group\_set\_intersect!Ruby API}
\input{\topdir/client/fragments/group_set_intersect}

\paragraph{Definition:}
\begin{rubycode}
async_group_set_intersect(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_set\_intersect}.

%%%%%%%%%%%%%%%%%%%% set_union %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{set\_union}}
\label{api:ruby:set_union}
\index{set\_union!Ruby API}
\input{\topdir/client/fragments/set_union}

\paragraph{Definition:}
\begin{rubycode}
set_union(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_set\_union}}
\label{api:ruby:async_set_union}
\index{async\_set\_union!Ruby API}
\input{\topdir/client/fragments/set_union}

\paragraph{Definition:}
\begin{rubycode}
async_set_union(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{set\_union}.

%%%%%%%%%%%%%%%%%%%% cond_set_union %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_set\_union}}
\label{api:ruby:cond_set_union}
\index{cond\_set\_union!Ruby API}
\input{\topdir/client/fragments/cond_set_union}

\paragraph{Definition:}
\begin{rubycode}
cond_set_union(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_set\_union}}
\label{api:ruby:async_cond_set_union}
\index{async\_cond\_set\_union!Ruby API}
\input{\topdir/client/fragments/cond_set_union}

\paragraph{Definition:}
\begin{rubycode}
async_cond_set_union(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_set\_union}.

%%%%%%%%%%%%%%%%%%%% group_set_union %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_set\_union}}
\label{api:ruby:group_set_union}
\index{group\_set\_union!Ruby API}
\input{\topdir/client/fragments/group_set_union}

\paragraph{Definition:}
\begin{rubycode}
group_set_union(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_set\_union}}
\label{api:ruby:async_group_set_union}
\index{async\_group\_set\_union!Ruby API}
\input{\topdir/client/fragments/group_set_union}

\paragraph{Definition:}
\begin{rubycode}
async_group_set_union(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_set\_union}.

%%%%%%%%%%%%%%%%%%%% document_rename %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{document\_rename}}
\label{api:ruby:document_rename}
\index{document\_rename!Ruby API}
\input{\topdir/client/fragments/document_rename}

\paragraph{Definition:}
\begin{rubycode}
document_rename(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_document\_rename}}
\label{api:ruby:async_document_rename}
\index{async\_document\_rename!Ruby API}
\input{\topdir/client/fragments/document_rename}

\paragraph{Definition:}
\begin{rubycode}
async_document_rename(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{document\_rename}.

%%%%%%%%%%%%%%%%%%%% cond_document_rename %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_document\_rename}}
\label{api:ruby:cond_document_rename}
\index{cond\_document\_rename!Ruby API}
\input{\topdir/client/fragments/cond_document_rename}

\paragraph{Definition:}
\begin{rubycode}
cond_document_rename(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_document\_rename}}
\label{api:ruby:async_cond_document_rename}
\index{async\_cond\_document\_rename!Ruby API}
\input{\topdir/client/fragments/cond_document_rename}

\paragraph{Definition:}
\begin{rubycode}
async_cond_document_rename(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_document\_rename}.

%%%%%%%%%%%%%%%%%%%% group_document_rename %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_document\_rename}}
\label{api:ruby:group_document_rename}
\index{group\_document\_rename!Ruby API}
\input{\topdir/client/fragments/group_document_rename}

\paragraph{Definition:}
\begin{rubycode}
group_document_rename(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_document\_rename}}
\label{api:ruby:async_group_document_rename}
\index{async\_group\_document\_rename!Ruby API}
\input{\topdir/client/fragments/group_document_rename}

\paragraph{Definition:}
\begin{rubycode}
async_group_document_rename(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_document\_rename}.

%%%%%%%%%%%%%%%%%%%% document_unset %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{document\_unset}}
\label{api:ruby:document_unset}
\index{document\_unset!Ruby API}
\input{\topdir/client/fragments/document_unset}

\paragraph{Definition:}
\begin{rubycode}
document_unset(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_document\_unset}}
\label{api:ruby:async_document_unset}
\index{async\_document\_unset!Ruby API}
\input{\topdir/client/fragments/document_unset}

\paragraph{Definition:}
\begin{rubycode}
async_document_unset(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{document\_unset}.

%%%%%%%%%%%%%%%%%%%% cond_document_unset %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_document\_unset}}
\label{api:ruby:cond_document_unset}
\index{cond\_document\_unset!Ruby API}
\input{\topdir/client/fragments/cond_document_unset}

\paragraph{Definition:}
\begin{rubycode}
cond_document_unset(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_document\_unset}}
\label{api:ruby:async_cond_document_unset}
\index{async\_cond\_document\_unset!Ruby API}
\input{\topdir/client/fragments/cond_document_unset}

\paragraph{Definition:}
\begin{rubycode}
async_cond_document_unset(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_document\_unset}.

%%%%%%%%%%%%%%%%%%%% group_document_unset %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_document\_unset}}
\label{api:ruby:group_document_unset}
\index{group\_document\_unset!Ruby API}
\input{\topdir/client/fragments/group_document_unset}

\paragraph{Definition:}
\begin{rubycode}
group_document_unset(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_document\_unset}}
\label{api:ruby:async_group_document_unset}
\index{async\_group\_document\_unset!Ruby API}
\input{\topdir/client/fragments/group_document_unset}

\paragraph{Definition:}
\begin{rubycode}
async_group_document_unset(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_document\_unset}.

%%%%%%%%%%%%%%%%%%%% map_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{map\_add}}
\label{api:ruby:map_add}
\index{map\_add!Ruby API}
\input{\topdir/client/fragments/map_add}

\paragraph{Definition:}
\begin{rubycode}
map_add(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_map\_add}}
\label{api:ruby:async_map_add}
\index{async\_map\_add!Ruby API}
\input{\topdir/client/fragments/map_add}

\paragraph{Definition:}
\begin{rubycode}
async_map_add(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{map\_add}.

%%%%%%%%%%%%%%%%%%%% cond_map_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_map\_add}}
\label{api:ruby:cond_map_add}
\index{cond\_map\_add!Ruby API}
\input{\topdir/client/fragments/cond_map_add}

\paragraph{Definition:}
\begin{rubycode}
cond_map_add(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_map\_add}}
\label{api:ruby:async_cond_map_add}
\index{async\_cond\_map\_add!Ruby API}
\input{\topdir/client/fragments/cond_map_add}

\paragraph{Definition:}
\begin{rubycode}
async_cond_map_add(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_map\_add}.

%%%%%%%%%%%%%%%%%%%% group_map_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_map\_add}}
\label{api:ruby:group_map_add}
\index{group\_map\_add!Ruby API}
\input{\topdir/client/fragments/group_map_add}

\paragraph{Definition:}
\begin{rubycode}
group_map_add(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_map\_add}}
\label{api:ruby:async_group_map_add}
\index{async\_group\_map\_add!Ruby API}
\input{\topdir/client/fragments/group_map_add}

\paragraph{Definition:}
\begin{rubycode}
async_group_map_add(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_map\_add}.

%%%%%%%%%%%%%%%%%%%% map_remove %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{map\_remove}}
\label{api:ruby:map_remove}
\index{map\_remove!Ruby API}
\input{\topdir/client/fragments/map_remove}

\paragraph{Definition:}
\begin{rubycode}
map_remove(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_map\_remove}}
\label{api:ruby:async_map_remove}
\index{async\_map\_remove!Ruby API}
\input{\topdir/client/fragments/map_remove}

\paragraph{Definition:}
\begin{rubycode}
async_map_remove(spacename, key, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{map\_remove}.

%%%%%%%%%%%%%%%%%%%% cond_map_remove %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_map\_remove}}
\label{api:ruby:cond_map_remove}
\index{cond\_map\_remove!Ruby API}
\input{\topdir/client/fragments/cond_map_remove}

\paragraph{Definition:}
\begin{rubycode}
cond_map_remove(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_map\_remove}}
\label{api:ruby:async_cond_map_remove}
\index{async\_cond\_map\_remove!Ruby API}
\input{\topdir/client/fragments/cond_map_remove}

\paragraph{Definition:}
\begin{rubycode}
async_cond_map_remove(spacename, key, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_map\_remove}.

%%%%%%%%%%%%%%%%%%%% group_map_remove %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_map\_remove}}
\label{api:ruby:group_map_remove}
\index{group\_map\_remove!Ruby API}
\input{\topdir/client/fragments/group_map_remove}

\paragraph{Definition:}
\begin{rubycode}
group_map_remove(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_map\_remove}}
\label{api:ruby:async_group_map_remove}
\index{async\_group\_map\_remove!Ruby API}
\input{\topdir/client/fragments/group_map_remove}

\paragraph{Definition:}
\begin{rubycode}
async_group_map_remove(spacename, predicates, attributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{attributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_map\_remove}.

%%%%%%%%%%%%%%%%%%%% map_atomic_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{map\_atomic\_add}}
\label{api:ruby:map_atomic_add}
\index{map\_atomic\_add!Ruby API}
\input{\topdir/client/fragments/map_atomic_add}

\paragraph{Definition:}
\begin{rubycode}
map_atomic_add(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_map\_atomic\_add}}
\label{api:ruby:async_map_atomic_add}
\index{async\_map\_atomic\_add!Ruby API}
\input{\topdir/client/fragments/map_atomic_add}

\paragraph{Definition:}
\begin{rubycode}
async_map_atomic_add(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{map\_atomic\_add}.

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_map\_atomic\_add}}
\label{api:ruby:cond_map_atomic_add}
\index{cond\_map\_atomic\_add!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_add}

\paragraph{Definition:}
\begin{rubycode}
cond_map_atomic_add(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_map\_atomic\_add}}
\label{api:ruby:async_cond_map_atomic_add}
\index{async\_cond\_map\_atomic\_add!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_add}

\paragraph{Definition:}
\begin{rubycode}
async_cond_map_atomic_add(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_map\_atomic\_add}.

%%%%%%%%%%%%%%%%%%%% group_map_atomic_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_map\_atomic\_add}}
\label{api:ruby:group_map_atomic_add}
\index{group\_map\_atomic\_add!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_add}

\paragraph{Definition:}
\begin{rubycode}
group_map_atomic_add(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_map\_atomic\_add}}
\label{api:ruby:async_group_map_atomic_add}
\index{async\_group\_map\_atomic\_add!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_add}

\paragraph{Definition:}
\begin{rubycode}
async_group_map_atomic_add(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_map\_atomic\_add}.

%%%%%%%%%%%%%%%%%%%% map_atomic_sub %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{map\_atomic\_sub}}
\label{api:ruby:map_atomic_sub}
\index{map\_atomic\_sub!Ruby API}
\input{\topdir/client/fragments/map_atomic_sub}

\paragraph{Definition:}
\begin{rubycode}
map_atomic_sub(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_map\_atomic\_sub}}
\label{api:ruby:async_map_atomic_sub}
\index{async\_map\_atomic\_sub!Ruby API}
\input{\topdir/client/fragments/map_atomic_sub}

\paragraph{Definition:}
\begin{rubycode}
async_map_atomic_sub(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{map\_atomic\_sub}.

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_sub %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_map\_atomic\_sub}}
\label{api:ruby:cond_map_atomic_sub}
\index{cond\_map\_atomic\_sub!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_sub}

\paragraph{Definition:}
\begin{rubycode}
cond_map_atomic_sub(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_map\_atomic\_sub}}
\label{api:ruby:async_cond_map_atomic_sub}
\index{async\_cond\_map\_atomic\_sub!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_sub}

\paragraph{Definition:}
\begin{rubycode}
async_cond_map_atomic_sub(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_map\_atomic\_sub}.

%%%%%%%%%%%%%%%%%%%% group_map_atomic_sub %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_map\_atomic\_sub}}
\label{api:ruby:group_map_atomic_sub}
\index{group\_map\_atomic\_sub!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_sub}

\paragraph{Definition:}
\begin{rubycode}
group_map_atomic_sub(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_map\_atomic\_sub}}
\label{api:ruby:async_group_map_atomic_sub}
\index{async\_group\_map\_atomic\_sub!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_sub}

\paragraph{Definition:}
\begin{rubycode}
async_group_map_atomic_sub(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_map\_atomic\_sub}.

%%%%%%%%%%%%%%%%%%%% map_atomic_mul %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{map\_atomic\_mul}}
\label{api:ruby:map_atomic_mul}
\index{map\_atomic\_mul!Ruby API}
\input{\topdir/client/fragments/map_atomic_mul}

\paragraph{Definition:}
\begin{rubycode}
map_atomic_mul(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_map\_atomic\_mul}}
\label{api:ruby:async_map_atomic_mul}
\index{async\_map\_atomic\_mul!Ruby API}
\input{\topdir/client/fragments/map_atomic_mul}

\paragraph{Definition:}
\begin{rubycode}
async_map_atomic_mul(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{map\_atomic\_mul}.

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_mul %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_map\_atomic\_mul}}
\label{api:ruby:cond_map_atomic_mul}
\index{cond\_map\_atomic\_mul!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_mul}

\paragraph{Definition:}
\begin{rubycode}
cond_map_atomic_mul(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_map\_atomic\_mul}}
\label{api:ruby:async_cond_map_atomic_mul}
\index{async\_cond\_map\_atomic\_mul!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_mul}

\paragraph{Definition:}
\begin{rubycode}
async_cond_map_atomic_mul(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_map\_atomic\_mul}.

%%%%%%%%%%%%%%%%%%%% group_map_atomic_mul %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_map\_atomic\_mul}}
\label{api:ruby:group_map_atomic_mul}
\index{group\_map\_atomic\_mul!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_mul}

\paragraph{Definition:}
\begin{rubycode}
group_map_atomic_mul(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_map\_atomic\_mul}}
\label{api:ruby:async_group_map_atomic_mul}
\index{async\_group\_map\_atomic\_mul!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_mul}

\paragraph{Definition:}
\begin{rubycode}
async_group_map_atomic_mul(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_map\_atomic\_mul}.

%%%%%%%%%%%%%%%%%%%% map_atomic_div %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{map\_atomic\_div}}
\label{api:ruby:map_atomic_div}
\index{map\_atomic\_div!Ruby API}
\input{\topdir/client/fragments/map_atomic_div}

\paragraph{Definition:}
\begin{rubycode}
map_atomic_div(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_map\_atomic\_div}}
\label{api:ruby:async_map_atomic_div}
\index{async\_map\_atomic\_div!Ruby API}
\input{\topdir/client/fragments/map_atomic_div}

\paragraph{Definition:}
\begin{rubycode}
async_map_atomic_div(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{map\_atomic\_div}.

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_div %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_map\_atomic\_div}}
\label{api:ruby:cond_map_atomic_div}
\index{cond\_map\_atomic\_div!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_div}

\paragraph{Definition:}
\begin{rubycode}
cond_map_atomic_div(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_map\_atomic\_div}}
\label{api:ruby:async_cond_map_atomic_div}
\index{async\_cond\_map\_atomic\_div!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_div}

\paragraph{Definition:}
\begin{rubycode}
async_cond_map_atomic_div(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_map\_atomic\_div}.

%%%%%%%%%%%%%%%%%%%% group_map_atomic_div %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_map\_atomic\_div}}
\label{api:ruby:group_map_atomic_div}
\index{group\_map\_atomic\_div!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_div}

\paragraph{Definition:}
\begin{rubycode}
group_map_atomic_div(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_map\_atomic\_div}}
\label{api:ruby:async_group_map_atomic_div}
\index{async\_group\_map\_atomic\_div!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_div}

\paragraph{Definition:}
\begin{rubycode}
async_group_map_atomic_div(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_map\_atomic\_div}.

%%%%%%%%%%%%%%%%%%%% map_atomic_mod %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{map\_atomic\_mod}}
\label{api:ruby:map_atomic_mod}
\index{map\_atomic\_mod!Ruby API}
\input{\topdir/client/fragments/map_atomic_mod}

\paragraph{Definition:}
\begin{rubycode}
map_atomic_mod(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_map\_atomic\_mod}}
\label{api:ruby:async_map_atomic_mod}
\index{async\_map\_atomic\_mod!Ruby API}
\input{\topdir/client/fragments/map_atomic_mod}

\paragraph{Definition:}
\begin{rubycode}
async_map_atomic_mod(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{map\_atomic\_mod}.

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_mod %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_map\_atomic\_mod}}
\label{api:ruby:cond_map_atomic_mod}
\index{cond\_map\_atomic\_mod!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_mod}

\paragraph{Definition:}
\begin{rubycode}
cond_map_atomic_mod(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_map\_atomic\_mod}}
\label{api:ruby:async_cond_map_atomic_mod}
\index{async\_cond\_map\_atomic\_mod!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_mod}

\paragraph{Definition:}
\begin{rubycode}
async_cond_map_atomic_mod(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_map\_atomic\_mod}.

%%%%%%%%%%%%%%%%%%%% group_map_atomic_mod %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_map\_atomic\_mod}}
\label{api:ruby:group_map_atomic_mod}
\index{group\_map\_atomic\_mod!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_mod}

\paragraph{Definition:}
\begin{rubycode}
group_map_atomic_mod(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_map\_atomic\_mod}}
\label{api:ruby:async_group_map_atomic_mod}
\index{async\_group\_map\_atomic\_mod!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_mod}

\paragraph{Definition:}
\begin{rubycode}
async_group_map_atomic_mod(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_map\_atomic\_mod}.

%%%%%%%%%%%%%%%%%%%% map_atomic_and %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{map\_atomic\_and}}
\label{api:ruby:map_atomic_and}
\index{map\_atomic\_and!Ruby API}
\input{\topdir/client/fragments/map_atomic_and}

\paragraph{Definition:}
\begin{rubycode}
map_atomic_and(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_map\_atomic\_and}}
\label{api:ruby:async_map_atomic_and}
\index{async\_map\_atomic\_and!Ruby API}
\input{\topdir/client/fragments/map_atomic_and}

\paragraph{Definition:}
\begin{rubycode}
async_map_atomic_and(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{map\_atomic\_and}.

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_and %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_map\_atomic\_and}}
\label{api:ruby:cond_map_atomic_and}
\index{cond\_map\_atomic\_and!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_and}

\paragraph{Definition:}
\begin{rubycode}
cond_map_atomic_and(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_map\_atomic\_and}}
\label{api:ruby:async_cond_map_atomic_and}
\index{async\_cond\_map\_atomic\_and!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_and}

\paragraph{Definition:}
\begin{rubycode}
async_cond_map_atomic_and(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_map\_atomic\_and}.

%%%%%%%%%%%%%%%%%%%% group_map_atomic_and %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_map\_atomic\_and}}
\label{api:ruby:group_map_atomic_and}
\index{group\_map\_atomic\_and!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_and}

\paragraph{Definition:}
\begin{rubycode}
group_map_atomic_and(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_map\_atomic\_and}}
\label{api:ruby:async_group_map_atomic_and}
\index{async\_group\_map\_atomic\_and!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_and}

\paragraph{Definition:}
\begin{rubycode}
async_group_map_atomic_and(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_map\_atomic\_and}.

%%%%%%%%%%%%%%%%%%%% map_atomic_or %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{map\_atomic\_or}}
\label{api:ruby:map_atomic_or}
\index{map\_atomic\_or!Ruby API}
\input{\topdir/client/fragments/map_atomic_or}

\paragraph{Definition:}
\begin{rubycode}
map_atomic_or(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_map\_atomic\_or}}
\label{api:ruby:async_map_atomic_or}
\index{async\_map\_atomic\_or!Ruby API}
\input{\topdir/client/fragments/map_atomic_or}

\paragraph{Definition:}
\begin{rubycode}
async_map_atomic_or(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{map\_atomic\_or}.

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_or %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_map\_atomic\_or}}
\label{api:ruby:cond_map_atomic_or}
\index{cond\_map\_atomic\_or!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_or}

\paragraph{Definition:}
\begin{rubycode}
cond_map_atomic_or(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_map\_atomic\_or}}
\label{api:ruby:async_cond_map_atomic_or}
\index{async\_cond\_map\_atomic\_or!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_or}

\paragraph{Definition:}
\begin{rubycode}
async_cond_map_atomic_or(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_map\_atomic\_or}.

%%%%%%%%%%%%%%%%%%%% group_map_atomic_or %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_map\_atomic\_or}}
\label{api:ruby:group_map_atomic_or}
\index{group\_map\_atomic\_or!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_or}

\paragraph{Definition:}
\begin{rubycode}
group_map_atomic_or(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_map\_atomic\_or}}
\label{api:ruby:async_group_map_atomic_or}
\index{async\_group\_map\_atomic\_or!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_or}

\paragraph{Definition:}
\begin{rubycode}
async_group_map_atomic_or(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_map\_atomic\_or}.

%%%%%%%%%%%%%%%%%%%% map_atomic_xor %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{map\_atomic\_xor}}
\label{api:ruby:map_atomic_xor}
\index{map\_atomic\_xor!Ruby API}
\input{\topdir/client/fragments/map_atomic_xor}

\paragraph{Definition:}
\begin{rubycode}
map_atomic_xor(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_map\_atomic\_xor}}
\label{api:ruby:async_map_atomic_xor}
\index{async\_map\_atomic\_xor!Ruby API}
\input{\topdir/client/fragments/map_atomic_xor}

\paragraph{Definition:}
\begin{rubycode}
async_map_atomic_xor(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{map\_atomic\_xor}.

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_xor %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_map\_atomic\_xor}}
\label{api:ruby:cond_map_atomic_xor}
\index{cond\_map\_atomic\_xor!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_xor}

\paragraph{Definition:}
\begin{rubycode}
cond_map_atomic_xor(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_map\_atomic\_xor}}
\label{api:ruby:async_cond_map_atomic_xor}
\index{async\_cond\_map\_atomic\_xor!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_xor}

\paragraph{Definition:}
\begin{rubycode}
async_cond_map_atomic_xor(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_map\_atomic\_xor}.

%%%%%%%%%%%%%%%%%%%% group_map_atomic_xor %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_map\_atomic\_xor}}
\label{api:ruby:group_map_atomic_xor}
\index{group\_map\_atomic\_xor!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_xor}

\paragraph{Definition:}
\begin{rubycode}
group_map_atomic_xor(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_map\_atomic\_xor}}
\label{api:ruby:async_group_map_atomic_xor}
\index{async\_group\_map\_atomic\_xor!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_xor}

\paragraph{Definition:}
\begin{rubycode}
async_group_map_atomic_xor(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_map\_atomic\_xor}.

%%%%%%%%%%%%%%%%%%%% map_string_prepend %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{map\_string\_prepend}}
\label{api:ruby:map_string_prepend}
\index{map\_string\_prepend!Ruby API}
\input{\topdir/client/fragments/map_string_prepend}

\paragraph{Definition:}
\begin{rubycode}
map_string_prepend(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_map\_string\_prepend}}
\label{api:ruby:async_map_string_prepend}
\index{async\_map\_string\_prepend!Ruby API}
\input{\topdir/client/fragments/map_string_prepend}

\paragraph{Definition:}
\begin{rubycode}
async_map_string_prepend(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{map\_string\_prepend}.

%%%%%%%%%%%%%%%%%%%% cond_map_string_prepend %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_map\_string\_prepend}}
\label{api:ruby:cond_map_string_prepend}
\index{cond\_map\_string\_prepend!Ruby API}
\input{\topdir/client/fragments/cond_map_string_prepend}

\paragraph{Definition:}
\begin{rubycode}
cond_map_string_prepend(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_map\_string\_prepend}}
\label{api:ruby:async_cond_map_string_prepend}
\index{async\_cond\_map\_string\_prepend!Ruby API}
\input{\topdir/client/fragments/cond_map_string_prepend}

\paragraph{Definition:}
\begin{rubycode}
async_cond_map_string_prepend(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_map\_string\_prepend}.

%%%%%%%%%%%%%%%%%%%% group_map_string_prepend %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_map\_string\_prepend}}
\label{api:ruby:group_map_string_prepend}
\index{group\_map\_string\_prepend!Ruby API}
\input{\topdir/client/fragments/group_map_string_prepend}

\paragraph{Definition:}
\begin{rubycode}
group_map_string_prepend(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_map\_string\_prepend}}
\label{api:ruby:async_group_map_string_prepend}
\index{async\_group\_map\_string\_prepend!Ruby API}
\input{\topdir/client/fragments/group_map_string_prepend}

\paragraph{Definition:}
\begin{rubycode}
async_group_map_string_prepend(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_map\_string\_prepend}.

%%%%%%%%%%%%%%%%%%%% map_string_append %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{map\_string\_append}}
\label{api:ruby:map_string_append}
\index{map\_string\_append!Ruby API}
\input{\topdir/client/fragments/map_string_append}

\paragraph{Definition:}
\begin{rubycode}
map_string_append(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_map\_string\_append}}
\label{api:ruby:async_map_string_append}
\index{async\_map\_string\_append!Ruby API}
\input{\topdir/client/fragments/map_string_append}

\paragraph{Definition:}
\begin{rubycode}
async_map_string_append(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{map\_string\_append}.

%%%%%%%%%%%%%%%%%%%% cond_map_string_append %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_map\_string\_append}}
\label{api:ruby:cond_map_string_append}
\index{cond\_map\_string\_append!Ruby API}
\input{\topdir/client/fragments/cond_map_string_append}

\paragraph{Definition:}
\begin{rubycode}
cond_map_string_append(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_map\_string\_append}}
\label{api:ruby:async_cond_map_string_append}
\index{async\_cond\_map\_string\_append!Ruby API}
\input{\topdir/client/fragments/cond_map_string_append}

\paragraph{Definition:}
\begin{rubycode}
async_cond_map_string_append(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_map\_string\_append}.

%%%%%%%%%%%%%%%%%%%% group_map_string_append %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_map\_string\_append}}
\label{api:ruby:group_map_string_append}
\index{group\_map\_string\_append!Ruby API}
\input{\topdir/client/fragments/group_map_string_append}

\paragraph{Definition:}
\begin{rubycode}
group_map_string_append(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_map\_string\_append}}
\label{api:ruby:async_group_map_string_append}
\index{async\_group\_map\_string\_append!Ruby API}
\input{\topdir/client/fragments/group_map_string_append}

\paragraph{Definition:}
\begin{rubycode}
async_group_map_string_append(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_map\_string\_append}.

%%%%%%%%%%%%%%%%%%%% map_atomic_min %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{map\_atomic\_min}}
\label{api:ruby:map_atomic_min}
\index{map\_atomic\_min!Ruby API}
\input{\topdir/client/fragments/map_atomic_min}

\paragraph{Definition:}
\begin{rubycode}
map_atomic_min(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_map\_atomic\_min}}
\label{api:ruby:async_map_atomic_min}
\index{async\_map\_atomic\_min!Ruby API}
\input{\topdir/client/fragments/map_atomic_min}

\paragraph{Definition:}
\begin{rubycode}
async_map_atomic_min(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{map\_atomic\_min}.

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_min %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_map\_atomic\_min}}
\label{api:ruby:cond_map_atomic_min}
\index{cond\_map\_atomic\_min!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_min}

\paragraph{Definition:}
\begin{rubycode}
cond_map_atomic_min(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_map\_atomic\_min}}
\label{api:ruby:async_cond_map_atomic_min}
\index{async\_cond\_map\_atomic\_min!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_min}

\paragraph{Definition:}
\begin{rubycode}
async_cond_map_atomic_min(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_map\_atomic\_min}.

%%%%%%%%%%%%%%%%%%%% group_map_atomic_min %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_map\_atomic\_min}}
\label{api:ruby:group_map_atomic_min}
\index{group\_map\_atomic\_min!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_min}

\paragraph{Definition:}
\begin{rubycode}
group_map_atomic_min(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_map\_atomic\_min}}
\label{api:ruby:async_group_map_atomic_min}
\index{async\_group\_map\_atomic\_min!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_min}

\paragraph{Definition:}
\begin{rubycode}
async_group_map_atomic_min(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_map\_atomic\_min}.

%%%%%%%%%%%%%%%%%%%% map_atomic_max %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{map\_atomic\_max}}
\label{api:ruby:map_atomic_max}
\index{map\_atomic\_max!Ruby API}
\input{\topdir/client/fragments/map_atomic_max}

\paragraph{Definition:}
\begin{rubycode}
map_atomic_max(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_map\_atomic\_max}}
\label{api:ruby:async_map_atomic_max}
\index{async\_map\_atomic\_max!Ruby API}
\input{\topdir/client/fragments/map_atomic_max}

\paragraph{Definition:}
\begin{rubycode}
async_map_atomic_max(spacename, key, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{map\_atomic\_max}.

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_max %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{cond\_map\_atomic\_max}}
\label{api:ruby:cond_map_atomic_max}
\index{cond\_map\_atomic\_max!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_max}

\paragraph{Definition:}
\begin{rubycode}
cond_map_atomic_max(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status}

\pagebreak
\subsubsection{\code{async\_cond\_map\_atomic\_max}}
\label{api:ruby:async_cond_map_atomic_max}
\index{async\_cond\_map\_atomic\_max!Ruby API}
\input{\topdir/client/fragments/cond_map_atomic_max}

\paragraph{Definition:}
\begin{rubycode}
async_cond_map_atomic_max(spacename, key, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{key}\\
\input{\topdir/ruby/client/fragments/in_asynccall_key}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status}

\paragraph{See also:}  This is the asynchronous form of \code{cond\_map\_atomic\_max}.

%%%%%%%%%%%%%%%%%%%% group_map_atomic_max %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{group\_map\_atomic\_max}}
\label{api:ruby:group_map_atomic_max}
\index{group\_map\_atomic\_max!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_max}

\paragraph{Definition:}
\begin{rubycode}
group_map_atomic_max(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_group\_map\_atomic\_max}}
\label{api:ruby:async_group_map_atomic_max}
\index{async\_group\_map\_atomic\_max!Ruby API}
\input{\topdir/client/fragments/group_map_atomic_max}

\paragraph{Definition:}
\begin{rubycode}
async_group_map_atomic_max(spacename, predicates, mapattributes)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\item \code{mapattributes}\\
\input{\topdir/ruby/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{group\_map\_atomic\_max}.

%%%%%%%%%%%%%%%%%%%% search %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{search}}
\label{api:ruby:search}
\index{search!Ruby API}
\input{\topdir/client/fragments/search}

\paragraph{Definition:}
\begin{rubycode}
search(spacename, predicates)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_iterator_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_iterator_predicates}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_iterator__status_attributes}

%%%%%%%%%%%%%%%%%%%% sorted_search %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{sorted\_search}}
\label{api:ruby:sorted_search}
\index{sorted\_search!Ruby API}
\input{\topdir/client/fragments/sorted_search}

\paragraph{Definition:}
\begin{rubycode}
sorted_search(spacename, predicates, sortby, limit, maxmin)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_iterator_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_iterator_predicates}
\item \code{sortby}\\
\input{\topdir/ruby/client/fragments/in_iterator_sortby}
\item \code{limit}\\
\input{\topdir/ruby/client/fragments/in_iterator_limit}
\item \code{maxmin}\\
\input{\topdir/ruby/client/fragments/in_iterator_maxmin}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_iterator__status_attributes}

%%%%%%%%%%%%%%%%%%%% count %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsubsection{\code{count}}
\label{api:ruby:count}
\index{count!Ruby API}
\input{\topdir/client/fragments/count}

\paragraph{Definition:}
\begin{rubycode}
count(spacename, predicates)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_asynccall__status_count}

\pagebreak
\subsubsection{\code{async\_count}}
\label{api:ruby:async_count}
\index{async\_count!Ruby API}
\input{\topdir/client/fragments/count}

\paragraph{Definition:}
\begin{rubycode}
async_count(spacename, predicates)
\end{rubycode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{spacename}\\
\input{\topdir/ruby/client/fragments/in_asynccall_spacename}
\item \code{predicates}\\
\input{\topdir/ruby/client/fragments/in_asynccall_predicates}
\end{itemize}

\paragraph{Returns:}
\input{\topdir/ruby/client/fragments/return_async_asynccall__status_count}

\paragraph{See also:}  This is the asynchronous form of \code{count}.
